
/**
 * @method
 * @desc 过滤组件
 * @param {Array} jsonObj json对象或数组
 * @param {String} key 对应的字段
 * @param {String} value 字段值
 * @returns {Object} 返回组件对象
 */
export function filterItem(jsonObj, key, value) {
    // 循环所有键
    let array = []
    for (let v in jsonObj) {
        let element = jsonObj[v]
        // 1.判断是对象或者数组
        if (typeof (element) == 'object') {
            let result = filterItem(element, key, value)
            if (result) return result
        } else {
            if (v == key) {
                if (element == value) return jsonObj
            }
        }
    }
}

/**
 * @method
 * @desc 随机生成数字  
 * 示例：生成长度为 12 的随机数：randomNumber(12)
 * 示例：生成 3~23 之间的随机数：randomNumber(3, 23)
 * @param1 最小值 | 长度
 * @param2 最大值
 * @returns {Number} 生成后的数字
 */
export function randomNumber() {
    // 生成 最小值 到 最大值 区间的随机数
    const random = (min, max) => {
        return Math.floor(Math.random() * (max - min + 1) + min)
    }
    if (arguments.length === 1) {
        let [length] = arguments
        // 生成指定长度的随机数字，首位一定不是 0
        let nums = [...Array(length).keys()].map((i) => (i > 0 ? random(0, 9) : random(1, 9)))
        return parseInt(nums.join(''))
    } else if (arguments.length >= 2) {
        let [min, max] = arguments
        return random(min, max)
    } else {
        return Number.NaN
    }
}

/**
 * @method
 * @desc 随机生成字符串
 * @param length 字符串的长度
 * @param chats 可选字符串区间（只会生成传入的字符串中的字符）
 * @returns string 生成的字符串
 */
export function randomString(length, chats) {
    if (!length) length = 1
    if (!chats) chats = '0123456789qwertyuioplkjhgfdsazxcvbnm'
    let str = ''
    for (let i = 0; i < length; i++) {
        let num = randomNumber(0, chats.length - 1)
        str += chats[num]
    }
    return str
}

/**
 * @method
 * @desc 随机生成uuid
 * @returns {String} 生成的uuid
 */
export function randomUUID() {
    let chats = '0123456789abcdef'
    return randomString(32, chats)
}

/**
 * @method
 * @desc 深度克隆对象、数组
 * @param {Object|Array} obj 被克隆的对象
 * @returns 克隆后的对象
 */
export function cloneObject(obj) {
    return JSON.parse(JSON.stringify(obj))
}


/**
 * 获取当前时间
 * @returns 当前时间
 */
export function getNowDateTime() {

    let today = new Date();

    // 获取年、月、日、时、分、秒
    let year = today.getFullYear();
    let month = today.getMonth() + 1; // 月份是从 0 开始计数的，需要加1
    let day = today.getDate();
    let hours = today.getHours();
    let minutes = today.getMinutes();
    let seconds = today.getSeconds();

    // 格式化输出
    let formattedTime = year + "-" +
        (month < 10 ? "0" : "") + month + "-" +
        (day < 10 ? "0" : "") + day + " " +
        (hours < 10 ? "0" : "") + hours + ":" +
        (minutes < 10 ? "0" : "") + minutes + ":" +
        (seconds < 10 ? "0" : "") + seconds;

    return formattedTime;
}



/**
 * 合并数据。
 * 该函数接收现有数据和新数据作为输入，并将新数据合并到现有数据中。
 * 如果新数据是数组，则将其所有元素添加到现有数据数组中；
 * 如果新数据不是数组，则将其作为单个元素添加到现有数据数组中。
 * 
 * @param {Array} existingData 现有数据数组，默认为空数组。
 * @param {any} newData 新数据，可以是数组或任何其他类型。
 * @returns {Array} 合并后的数据数组。
 */
export function mergeData(existingData = [], newData) {
    // 如果新数据是数组，则将其所有元素合并到现有数据中
    if (Array.isArray(newData)) {
        return [...existingData, ...newData];
        // 如果新数据是非数组，则将其作为单个元素添加到现有数据中
    } else if (newData) {
        return [...existingData, newData];
    }
    // 如果新数据未定义或为空，则返回现有的数据数组
    return existingData;
};

/**
 * 判断数组对象是否包含某个特性属性
 * @param {*} arr  数组
 * @param {*} prop  属性名
 * @returns 
 */
export function hasProperty(arr, prop) {
    return arr.some(obj => Object.hasOwnProperty.call(obj, prop));
};



/**
 * 将正则表达式对象转换为字符串形式。
 * @param {RegExp} regex - 正则表达式对象。
 * @returns {string} 返回正则表达式的字符串表示，包括源字符串和标志位。
 */
export function regexToString(regex) {
    // 初始化标志位字符串
    let flags = '';
    // 根据正则表达式对象的属性，逐个添加对应的标志位字符
    if (regex.global) flags += 'g';
    if (regex.ignoreCase) flags += 'i';
    if (regex.multiline) flags += 'm';
    if (regex.dotAll) flags += 's';
    if (regex.unicode) flags += 'u';
    if (regex.sticky) flags += 'y';

    // 返回正则表达式源字符串和标志位组成的字符串
    return regex.source + (flags ? '/' + flags : '');
}

/**
 * 判断元素是否有滚动条
 * @param {*} element 
 * @returns true 或者 false，true 表示有滚动条，false 表示没有滚动条
 */
export function hasScrollbar(element) {
    // 计算元素的内容宽度（包括看不见的部分）与可见宽度
    const contentWidth = element.scrollWidth;
    const clientWidth = element.clientWidth;

    // 计算元素的内容高度（包括看不见的部分）与可见高度
    const contentHeight = element.scrollHeight;
    const clientHeight = element.clientHeight;

    // 如果内容的尺寸大于容器的可视尺寸，则存在滚动条
    return (contentWidth > clientWidth) || (contentHeight > clientHeight);
}
